package savet.gui.modelos;

import java.util.Date;
import java.util.List;
import java.util.Observable;
import savet.entidades.Trabalhador;
import savet.entidades.atributos.AtributoData;
import savet.entidades.atributos.CAGED;
import savet.entidades.atributos.Rais;
import savet.util.DataUtil;
import savet.util.Trabalhadores;

/**
 *
 * @author Adisson Marinho
 */
public class ModeloRaisCaged extends AbstractAtributoDataModel {

    public ModeloRaisCaged(Object[] colunas) {
        super(colunas);
    }

    public ModeloRaisCaged(Object[] colunas, Date inicio, Date fim) {
        super(colunas, inicio, fim);
    }

    @Override
    public Object getValueAt(int rowIndex, int columnIndex) {
        Trabalhador trabalhador = getTrabalhador(rowIndex);

        int raisCount = 0;
        int cagedCount = 0;
        for (int j = 0; j < getColumnCount(); j++) {

            if (getColumnName(j).equalsIgnoreCase("rais")) {
                if (j == columnIndex) {
                    return trabalhador.getRais().
                            getTodosAtributosData().
                            get(raisCount);
                }

                raisCount++;
            } else {
                if (j == columnIndex) {
                    return trabalhador.getCaged().
                            getAtributosData().
                            get(cagedCount);
                }
                cagedCount++;
            }
        }

        return null;
    }

    @Override
    public void setValueAt(Object aValue, int rowIndex, int columnIndex) {
        Trabalhador trabalhador = getTrabalhador(rowIndex);
        AtributoData att = (AtributoData) aValue;

        int raisCount = 0;
        int cagedCount = 0;
        for (int j = 0; j < getColumnCount(); j++) {

            if (getColumnName(j).equalsIgnoreCase("rais")) {

                if (j == columnIndex) {

                    trabalhador.getRais().
                            getTodosAtributosData().
                            set(raisCount, att);
                    return;
                }

                raisCount++;
            } else {

                if (j == columnIndex) {
                    trabalhador.getCaged().
                            getAtributosData().
                            set(cagedCount, att);
                    return;
                }
                cagedCount++;
            }
        }
    }

    public void elementoAdicionado(Trabalhador trabalhador) {
        criarRais(trabalhador);
        criarCaged(trabalhador);
        fireTableDataChanged();
    }

    public void elementoRemovido(Trabalhador trabalhador) {
        fireTableDataChanged();
    }

    @Override
    protected void carregarAtributos() {
        for (Trabalhador trabalhador : trabalhadores) {
            criarRais(trabalhador);
            criarCaged(trabalhador);
        }
    }

    private void criarRais(Trabalhador trabalhador) {
        if (trabalhador.getRais() == null) {
            Rais rais = new Rais();
            rais.setTrabalhador(trabalhador);
            rais.setTodosAtributosData(Trabalhadores.getListaAtributoAnos(inicioPeriodo, fimPeriodo));
            trabalhador.setRais(rais);

        } else {
            atualizarRais(trabalhador);
        }
    }

    private void criarCaged(Trabalhador trabalhador) {
        if (trabalhador.getCaged() == null) {
            CAGED caged = new CAGED();
            caged.setTrabalhador(trabalhador);
            caged.setAtributosData(Trabalhadores.getListaAtributoMeses(inicioPeriodo, fimPeriodo));
            trabalhador.setCaged(caged);
        } else {
            atualizarCAGED(trabalhador);
        }
    }

    private void atualizarCAGED(Trabalhador t) {
        CAGED caged = t.getCaged();
        if (caged != null) {

            List<AtributoData> oldAttData = caged.getAtributosData();
            List<AtributoData> newAttData = Trabalhadores.getListaAtributoMeses(inicioPeriodo, fimPeriodo);

            atualizaListaAtributos(newAttData, oldAttData);
            t.getCaged().setAtributosData(newAttData);
        } else {
            atualizarCAGED(t);
        }
    }

    private void atualizarRais(Trabalhador t) {
        Rais rais = t.getRais();
        if (rais != null) {
            List<AtributoData> oldAttData = rais.getTodosAtributosData();
            List<AtributoData> newAttData = Trabalhadores.getListaAtributoAnos(inicioPeriodo, fimPeriodo);

            super.atualizaListaAtributos(newAttData, oldAttData);
            t.getRais().setTodosAtributosData(newAttData);
        } else {
            criarRais(t);
        }
    }

//    private void atualizaListaAtributos(List<AtributoData> newAttData, List<AtributoData> oldAttData) {
//        //Verifica quais atributos ja foram notificados
//        for (int i = 0; i < newAttData.size(); i++) {
//            int index = oldAttData.indexOf(newAttData.get(i));
//
//            if (index != -1) {
//                AtributoData oldAtt = oldAttData.get(index);
//                newAttData.set(i, oldAtt);
//            }
//            Date newData = newAttData.get(i).getData();
//            for (int j = 0; j < oldAttData.size(); j++) {
//                AtributoData oldAtt = oldAttData.get(j);
//                Date oldData = oldAtt.getData();
//                // Verifica se a data dos atributos sao iguais
//                if (DataUtil.equals(newData, oldData, DataUtil.FORMATO_MES_ANO)) {
//                    System.out.println("OD: " + DataUtil.converteDateToString(oldData, "MM/yyyy") +
//                            " | ND: " + DataUtil.converteDateToString(newData, "MM/yyyy"));
//                    newAttData.set(i, oldAtt);
//                    break;
//                }
//            }
//        }
//    }
    @Override
    public void update(Observable o, Object arg) {
        if (arg instanceof Trabalhador) {
            Trabalhador t = (Trabalhador) arg;

            criarRais(t);
            criarCaged(t);

        }
    }
}
